/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package fachada;

import bancodados.ConexaoBD;
import clientes.Cliente;
import clientes.NegocioCliente;
import clienteslogados.ClienteLogado;
import clienteslogados.NegocioClienteLogado;
import eventop2p.EventoP2P;
import eventop2p.NegocioEventoP2P;
import eventos.Evento;
import eventos.NegocioEvento;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Vector;
import tiposeventos.NegocioTipoEvento;
import tiposeventos.TipoEvento;
import tiposfisicos.NegocioTipoFisico;
import tiposfisicos.TipoFisico;
import tiposstatus.NegocioTipoStatus;
import tiposstatus.TipoStatus;

/**
 *
 * @author Anderson
 */
public class Fachada {
    NegocioCliente negocioCliente;
    NegocioClienteLogado negocioClienteLogado;
    NegocioEvento negocioEvento;
    NegocioEventoP2P negocioEventoP2P;
    NegocioTipoEvento negocioTipoEvento;
    NegocioTipoStatus negocioTipoStatus;
    NegocioTipoFisico negocioTipoFisico;

    private static Fachada fachada;

    private Fachada() throws ClassNotFoundException, SQLException
    {
        negocioCliente = new NegocioCliente();
        negocioClienteLogado = new NegocioClienteLogado();
        negocioEvento = new NegocioEvento();
        negocioEventoP2P = new NegocioEventoP2P();
        negocioTipoEvento = new NegocioTipoEvento();
        negocioTipoStatus = new NegocioTipoStatus();
        negocioTipoFisico = new NegocioTipoFisico();
    }
    public static Fachada getFachada() throws ClassNotFoundException, SQLException
    {
        if(fachada == null)
            fachada = new Fachada();
        return fachada;
    }
    public void commit() throws ClassNotFoundException, SQLException
    {
        ConexaoBD conexao = ConexaoBD.getConexao();
        conexao.commit();
    }

    public void rollback() throws ClassNotFoundException, SQLException
    {
        ConexaoBD conexao = ConexaoBD.getConexao();
        conexao.rollback();
    }

    public void begin() throws ClassNotFoundException, SQLException
    {
        ConexaoBD conexao = ConexaoBD.getConexao();
        conexao.begin();
    }
    public void adicionar(Cliente cliente) throws SQLException, ClassNotFoundException
    {
        negocioCliente.adicionar(cliente);
    }
    public void adicionar(ClienteLogado cliente) throws SQLException, ClassNotFoundException
    {
        negocioClienteLogado.adicionar(cliente);
    }
    public void adicionar(Evento evento) throws SQLException, ClassNotFoundException
    {
        negocioEvento.adicionar(evento);
    }
    public void adicionar(EventoP2P evento) throws SQLException, ClassNotFoundException
    {
        negocioEventoP2P.adicionar(evento);
    }
    public void adicionar(TipoEvento tipoEvento) throws SQLException, ClassNotFoundException
    {
        negocioTipoEvento.adicionar(tipoEvento);
    }
    public void adicionar(TipoFisico tipoFisico) throws SQLException, ClassNotFoundException
    {
        negocioTipoFisico.adicionar(tipoFisico);
    }
    public void adicionar(TipoStatus tipoStatus) throws SQLException, ClassNotFoundException
    {
        negocioTipoStatus.adicionar(tipoStatus);
    }

    public int getQuantidade() {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    public void remover(Cliente cliente) throws SQLException, ClassNotFoundException
    {
        negocioCliente.remover(cliente);
    }
    public void remover(Cliente cliente, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioCliente.remover(cliente, operacao);
    }
    public void remover(Cliente cliente, HashMap<String,String> operadores, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioCliente.remover(cliente, operadores, operacao);
    }
    public void remover(ClienteLogado cliente) throws SQLException, ClassNotFoundException
    {
        negocioClienteLogado.remover(cliente);
    }
    public void remover(ClienteLogado cliente, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioClienteLogado.remover(cliente, operacao);
    }
    public void remover(ClienteLogado cliente, HashMap<String,String> operadores, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioClienteLogado.remover(cliente, operadores, operacao);
    }
    public void remover(Evento evento) throws SQLException, ClassNotFoundException
    {
        negocioEvento.remover(evento);
    }
    public void remover(Evento evento, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioEvento.remover(evento, operacao);
    }
    public void remover(Evento evento, HashMap<String,String> operadores, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioEvento.remover(evento, operadores, operacao);
    }
    public void remover(EventoP2P evento) throws SQLException, ClassNotFoundException
    {
        negocioEventoP2P.remover(evento);
    }
    public void remover(EventoP2P evento, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioEventoP2P.remover(evento, operacao);
    }
    public void remover(EventoP2P evento, HashMap<String,String> operadores, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioEventoP2P.remover(evento, operadores, operacao);
    }
    public void remover(TipoEvento tipoEvento) throws SQLException, ClassNotFoundException
    {
        negocioTipoEvento.remover(tipoEvento);
    }
    public void remover(TipoEvento tipoEvento, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioTipoEvento.remover(tipoEvento, operacao);
    }
    public void remover(TipoEvento tipoEvento, HashMap<String,String> operadores, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioTipoEvento.remover(tipoEvento, operadores, operacao);
    }
    public void remover(TipoStatus tipoStatus) throws SQLException, ClassNotFoundException
    {
        negocioTipoStatus.remover(tipoStatus);
    }
    public void remover(TipoStatus tipoStatus, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioTipoStatus.remover(tipoStatus, operacao);
    }
    public void remover(TipoStatus tipoStatus, HashMap<String,String> operadores, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioTipoStatus.remover(tipoStatus, operadores, operacao);
    }
    public void remover(TipoFisico tipoFisico) throws SQLException, ClassNotFoundException
    {
        negocioTipoFisico.remover(tipoFisico);
    }
    public void remover(TipoFisico tipoFisico, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioTipoFisico.remover(tipoFisico, operacao);
    }
    public void remover(TipoFisico tipoFisico, HashMap<String,String> operadores, Boolean operacao) throws SQLException, ClassNotFoundException
    {
        negocioTipoFisico.remover(tipoFisico, operadores, operacao);
    }
    public void atualizar(Cliente cliente) throws SQLException, ClassNotFoundException
    {
        negocioCliente.atualizar(cliente);
    }
    public void atualizar(ClienteLogado cliente) throws SQLException, ClassNotFoundException
    {
        negocioClienteLogado.atualizar(cliente);
    }
    public void atualizar(Evento evento) throws SQLException, ClassNotFoundException
    {
        negocioEvento.atualizar(evento);
    }
    public void atualizar(EventoP2P evento) throws SQLException, ClassNotFoundException
    {
        negocioEventoP2P.atualizar(evento);
    }
    public void atualizar(TipoStatus tipoStatus) throws SQLException, ClassNotFoundException
    {
        negocioTipoStatus.atualizar(tipoStatus);
    }
    public void atualizar(TipoEvento tipoEvento) throws SQLException, ClassNotFoundException
    {
        negocioTipoEvento.atualizar(tipoEvento);
    }
    public void atualizar(TipoFisico tipoFisico) throws SQLException, ClassNotFoundException
    {
        negocioTipoFisico.atualizar(tipoFisico);
    }
    public Cliente procurar(Cliente cliente) throws SQLException, ClassNotFoundException
    {
        return negocioCliente.procurar(cliente);
    }
    public Cliente procurar(Cliente cliente, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioCliente.procurar(cliente, operadores);
    }
    public ClienteLogado procurar(ClienteLogado cliente) throws SQLException, ClassNotFoundException
    {
        return negocioClienteLogado.procurar(cliente);
    }
    public ClienteLogado procurar(ClienteLogado cliente, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioClienteLogado.procurar(cliente, operadores);
    }
    public Evento procurar(Evento evento) throws SQLException, ClassNotFoundException
    {
        return negocioEvento.procurar(evento);
    }
    public Evento procurar(Evento evento,HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioEvento.procurar(evento, operadores);
    }
    public EventoP2P procurar(EventoP2P eventoP2P) throws SQLException, ClassNotFoundException
    {
        return negocioEventoP2P.procurar(eventoP2P);
    }
    public EventoP2P procurar(EventoP2P eventoP2P, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioEventoP2P.procurar(eventoP2P, operadores);
    }
    public TipoEvento procurar(TipoEvento evento) throws SQLException, ClassNotFoundException
    {
        return negocioTipoEvento.procurar(evento);
    }
    public TipoEvento procurar(TipoEvento tipoEvento, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioTipoEvento.procurar(tipoEvento, operadores);
    }
    public TipoFisico procurar(TipoFisico tipoFisico) throws SQLException, ClassNotFoundException
    {
        return negocioTipoFisico.procurar(tipoFisico);
    }
    public TipoFisico procurar(TipoFisico tipoFisico, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioTipoFisico.procurar(tipoFisico, operadores);
    }
    public TipoStatus procurar(TipoStatus tipoStatus) throws SQLException, ClassNotFoundException
    {
        return negocioTipoStatus.procurar(tipoStatus);
    }
    public TipoStatus procurar(TipoStatus tipoStatus, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioTipoStatus.procurar(tipoStatus, operadores);
    }

public Vector procurarLista(Cliente cliente) throws SQLException, ClassNotFoundException
    {
        return negocioCliente.procurarLista(cliente);
    }
    public Vector procurarLista(Cliente cliente, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioCliente.procurarLista(cliente, operadores);
    }
    public Vector procurarLista(ClienteLogado cliente) throws SQLException, ClassNotFoundException
    {
        return negocioClienteLogado.procurarLista(cliente);
    }
    public Vector procurarLista(ClienteLogado cliente, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioClienteLogado.procurarLista(cliente, operadores);
    }
    public Vector procurarLista(Evento evento) throws SQLException, ClassNotFoundException
    {
        return negocioEvento.procurarLista(evento);
    }
    public Vector procurarLista(Evento evento,HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioEvento.procurarLista(evento, operadores);
    }
    public Vector procurarLista(EventoP2P eventoP2P) throws SQLException, ClassNotFoundException
    {
        return negocioEventoP2P.procurarLista(eventoP2P);
    }
    public Vector procurarLista(EventoP2P eventoP2P, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioEventoP2P.procurarLista(eventoP2P, operadores);
    }
    public Vector procurarLista(TipoEvento evento) throws SQLException, ClassNotFoundException
    {
        return negocioTipoEvento.procurarLista(evento);
    }
    public Vector procurarLista(TipoEvento tipoEvento, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioTipoEvento.procurarLista(tipoEvento, operadores);
    }
    public Vector procurarLista(TipoFisico tipoFisico) throws SQLException, ClassNotFoundException
    {
        return negocioTipoFisico.procurarLista(tipoFisico);
    }
    public Vector procurarLista(TipoFisico tipoFisico, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioTipoFisico.procurarLista(tipoFisico, operadores);
    }
    public Vector procurarLista(TipoStatus tipoStatus) throws SQLException, ClassNotFoundException
    {
        return negocioTipoStatus.procurarLista(tipoStatus);
    }
    public Vector procurarLista(TipoStatus tipoStatus, HashMap<String,String> operadores) throws SQLException, ClassNotFoundException
    {
        return negocioTipoStatus.procurarLista(tipoStatus, operadores);
    }
    public int getQuantidadeCliente() throws SQLException, ClassNotFoundException
    {
        return negocioCliente.getQuantidade();
    }
    public int getQuantidadeClienteLogado() throws SQLException, ClassNotFoundException
    {
        return negocioClienteLogado.getQuantidade();
    }
    public int getQuantidadeEvento() throws SQLException, ClassNotFoundException
    {
        return negocioEvento.getQuantidade();
    }
    public int getQuantidadeEventoP2P() throws SQLException, ClassNotFoundException
    {
        return negocioEventoP2P.getQuantidade();
    }
    public int getQuantidadeTipoEvento() throws SQLException, ClassNotFoundException
    {
        return negocioTipoEvento.getQuantidade();
    }
    public int getQuantidadeTipoFisico() throws SQLException, ClassNotFoundException
    {
        return negocioTipoFisico.getQuantidade();
    }
    public int getQuantidadeTipoStatus() throws SQLException, ClassNotFoundException
    {
        return negocioTipoStatus.getQuantidade();
    }
}
